package service

import (
	"context"
	"errors"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"log"
)

//获取node namespace pv 信息

type node struct {}
var Node node

type namespace struct {}
var Namespace namespace

var PersistentVolume persistentvolume
type persistentvolume struct {}

type NodeResp struct {
	Item  []corev1.Node `json:"item"`
	Total int  `json:"total"`
}
type NamespaceResp struct {
	Item  []corev1.Namespace `json:"item"`
	Total int  `json:"total"`
}

type PVResp struct {
	Item []corev1.PersistentVolume `json:"item"`
	Total int  `json:"total"`
}

//获取 node 信息
func (n *node)GetNodeInfo() (nodeResp *NodeResp,err error) {
	nodelist, err := K8s.ClientSet.CoreV1().Nodes().List(context.TODO(),metav1.ListOptions{})
	if err != nil {
		log.Printf("[ node ]资源列表获取失败：%s", err)
		return nil, errors.New("获取[ node ]列表失败" + err.Error())
	}
	//log.Println(nodelist.Items,"\n --------node--------")

	return &NodeResp{
		Item: nodelist.Items,
		Total: len(nodelist.Items),
	},nil
}

//获取 namespace 信息
func (n *namespace)GetNamespace() (namespaceResp *NamespaceResp,err error) {
	namespacelist, err := K8s.ClientSet.CoreV1().Namespaces().List(context.TODO(),metav1.ListOptions{})
	if err != nil {
		log.Printf("[ namespace ]资源列表获取失败：%s", err)
		return nil, errors.New("获取[ namespace ]列表失败" + err.Error())
	}

	return &NamespaceResp{
		Item: namespacelist.Items,
		Total: len(namespacelist.Items),
	},nil
}

//获取 pv 列表
func (p *persistentvolume)GetPVList() (pvResp *PVResp,err error) {
	pvlist, err := K8s.ClientSet.CoreV1().PersistentVolumes().List(context.TODO(),metav1.ListOptions{})
	if err != nil {
		log.Printf("[ PersistentVolume ]资源获取失败：%s", err)
		return nil, errors.New("获取[ PersistentVolume ]信息失败" + err.Error())
	}
	return &PVResp{
		Item: pvlist.Items,
		Total: len(pvlist.Items),
	},nil
}

//获取 pv 详情
func (p *persistentvolume)GetPVDetail(pvname string) (pv *corev1.PersistentVolume,err error) {
	pv, err = K8s.ClientSet.CoreV1().PersistentVolumes().Get(context.TODO(),pvname,metav1.GetOptions{})
	if err != nil {
		log.Printf("[ PersistentVolume ]资源获取失败：%s", err)
		return nil, errors.New("获取[ PersistentVolume ]信息失败" + err.Error())
	}
	return pv,nil
}


//获取 node 详细信息
func (n *node)GetNodeDetail(nodeName string) (node  *corev1.Node,err error) {
	node, err = K8s.ClientSet.CoreV1().Nodes().Get(context.TODO(),nodeName,metav1.GetOptions{})
	if err != nil {
		log.Printf("[ node ]资源获取失败：%s", err)
		return nil, errors.New("获取[ node ]信息失败" + err.Error())
	}

	return node,nil
}

//获取 namespace 详情
func (n *namespace)GetNSDetail(nameSpace string) (namespace *corev1.Namespace,err error) {
	namespace, err = K8s.ClientSet.CoreV1().Namespaces().Get(context.TODO(),nameSpace,metav1.GetOptions{})

	if err != nil {
		log.Printf("[ namespace ]资源获取失败：%s", err)
		return nil, errors.New("获取[ namespace ]失败" + err.Error())
	}

	return namespace,nil
}

//创建 namespace 详情
func (n *namespace)CreateNamespace(name string ) (err error) {
	nameSpace := &corev1.Namespace{
		TypeMeta:   metav1.TypeMeta{},
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		Spec:       corev1.NamespaceSpec{},
		Status:     corev1.NamespaceStatus{},
	}

	_, err = K8s.ClientSet.CoreV1().Namespaces().Create(context.TODO(),nameSpace,metav1.CreateOptions{})

	if err != nil {
		log.Printf("[ namespace ]创建失败：%s", err)
		return errors.New("[ namespace ]创建失败" + err.Error())
	}
	return nil
}


//删除 namespace 详情
func (n *namespace)DelNamespace(name string ) (err error) {
	err = K8s.ClientSet.CoreV1().Namespaces().Delete(context.TODO(),name,metav1.DeleteOptions{})
	if err != nil {
		log.Printf("[ namespace ]删除失败：%s", err)
		return errors.New("[ namespace ]删除失败" + err.Error())
	}
	return nil
}



//删除 PersistentVolumes 详情
func (p *persistentvolume)DeletePV(name string ) (err error) {
	err = K8s.ClientSet.CoreV1().PersistentVolumes().Delete(context.TODO(),name,metav1.DeleteOptions{})
	if err != nil {
		log.Printf("[ PersistentVolume ]删除失败：%s", err)
		return errors.New("[ PersistentVolume ]删除失败" + err.Error())
	}
	return nil
}


